package com.pro01.backend.controller;

import com.pro01.backend.pojo.PageResult;
import com.pro01.backend.pojo.Result;
import com.pro01.backend.pojo.User;
import com.pro01.backend.service.PointService;
import com.pro01.backend.service.UserService;
import com.pro01.backend.utils.JwtUtil;
import com.pro01.backend.utils.TokenUtil;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

/**
 * 后台用户管理接口 (仅限管理员)
 */
@RestController
@RequestMapping("/admin/users")
public class AdminUserController {

    @Autowired
    private UserService userService;

    @Autowired
    private PointService pointService;
    /**
     * 提取 JWT 中的 claims
     */
//    private Map<String, Object> getClaims(HttpServletRequest request) {
//        String token = request.getHeader("Authorization");
//        return JwtUtil.parseToken(token);
//    }

    /**
     * 判断当前用户是否为管理员
     */
//    private boolean isAdmin(HttpServletRequest request) {
//        Map<String, Object> claims = getClaims(request);
//        return claims != null && "ADMIN".equals(claims.get("role"));
//    }

    /**
     * 判断当前用户是否为管理员
     */
    private boolean isAdmin(HttpServletRequest request) {
        try {
            String role = TokenUtil.getRole(request); // ✅ 直接从工具类取角色
            return "ADMIN".equals(role);
        } catch (Exception e) {
            return false; // token 无效或缺失
        }
    }

    /**
     * 分页查询所有用户（仅限管理员）
     */
//    @GetMapping
//    public Result<List<User>> getAllUsers(HttpServletRequest request) {
//        if (!isAdmin(request)) {
//            return Result.error("无权限访问，仅管理员可用");
//        }
//        return Result.success(userService.getAllUsers());
//    }
    @GetMapping
    public Result<PageResult<User>> getAllUsers(@RequestParam(defaultValue = "1") int pageNum,
                                                @RequestParam(defaultValue = "10") int pageSize,
                                                HttpServletRequest request) {
        if (!isAdmin(request)) {
            return Result.error("无权限访问，仅管理员可用");
        }
        PageResult<User> pageResult = userService.getUsersPaged(pageNum, pageSize);
        return Result.success(pageResult);
    }


    /**
     * 刷新所有用户贡献值和等级（仅限管理员）
     */
    @PostMapping("/refresh-credit")
    public Result<?> refreshAllUserCredit(HttpServletRequest request) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作，仅管理员可用");
        }
        userService.refreshAllUsersCreditAndLevel();
        return Result.success("所有用户的贡献值和等级已刷新成功！");
    }

    /**
     * 封禁用户（仅限管理员）
     */
    @PutMapping("/ban/{userId}")
    public Result<Void> banUser(HttpServletRequest request, @PathVariable Long userId) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作");
        }
        return userService.banUser(userId) > 0 ? Result.success() : Result.error("封禁用户失败");
    }

    /**
     * 解封用户（仅管理员）
     */
    @PutMapping("/unban/{userId}")
    public Result<Void> unbanUser(HttpServletRequest request, @PathVariable Long userId) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作");
        }
        return userService.unbanUser(userId) > 0 ? Result.success() : Result.error("解封用户失败");
    }


    /**
     * 删除用户（仅限管理员）
     */
    @DeleteMapping("/{userId}")
    public Result<Void> deleteUser(HttpServletRequest request, @PathVariable Long userId) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作");
        }
        return userService.deleteUser(userId) > 0 ? Result.success() : Result.error("删除用户失败");
    }

    /**
     * 提拔用户为管理员（仅限管理员）
     */
    @PutMapping("/promote/{userId}")
    public Result<?> promoteToAdmin(HttpServletRequest request, @PathVariable Long userId) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作");
        }
        return userService.promoteToAdmin(userId) ? Result.success("用户已提升为管理员") : Result.error("操作失败");
    }

    /**
     * 查询所有用户的准分享率
     */
//    @GetMapping("/virtual-ratios/all")
//    public Result<List<Map<String, Object>>> getAllUsersVirtualRatio(HttpServletRequest request) {
//        if (!isAdmin(request)) {
//            return Result.error("无权限操作，只有管理员可用！");
//        }
//
//        try {
//            List<Map<String, Object>> result = userService.getAllUsersVirtualRatio();
//            return Result.success(result);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return Result.error("查询失败：" + e.getMessage());
//        }
//    }
    @GetMapping("/virtual-ratios/all")
    public Result<PageResult<Map<String, Object>>> getAllUsersVirtualRatio(
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "10") int pageSize,
            HttpServletRequest request) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作，只有管理员可用！");
        }

        try {
            PageResult<Map<String, Object>> result = userService.getAllUsersVirtualRatioPaged(pageNum, pageSize);
            return Result.success(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 降级管理员为普通用户（仅限管理员）
     */
    @PutMapping("/demote/{userId}")
    public Result<?> demoteToUser(HttpServletRequest request, @PathVariable Long userId) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作");
        }
        return userService.demoteToUser(userId) ? Result.success("管理员已降级为普通用户") : Result.error("操作失败");
    }

    /**
     * 警告用户（仅限管理员）
     */
    @PutMapping("/warn/{userId}")
    public Result<?> warnUser(HttpServletRequest request, @PathVariable Long userId) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作");
        }
        return userService.warnUser(userId) ? Result.success("用户已被警告") : Result.error("操作失败");
    }

    /**
     * 解除用户警告（仅限管理员）
     */
    @PutMapping("/unwarn/{userId}")
    public Result<?> removeWarning(HttpServletRequest request, @PathVariable Long userId) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作");
        }
        return userService.removeWarning(userId) ? Result.success("用户警告已解除") : Result.error("操作失败");
    }

    /**
     * 查询指定用户今天下载了多少次（仅限管理员）
     */
    @GetMapping("/downloads/count/{userId}")
    public Result<Integer> getTodayDownloadsByUserId(@PathVariable Long userId,
                                                     HttpServletRequest request) {
        if (!isAdmin(request)) {
            return Result.error("无权限，只有管理员可以查看！");
        }

        try {
            int downloadCount = userService.getTodayDownloadsByUserId(userId);
            return Result.success(downloadCount);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 查询指定用户的所有信息（仅限管理员）
     */
//    @GetMapping("/info/{id}")
//    public Result<Map<String, Object>> getSafeUserInfoById(@PathVariable Long id,
//                                                           HttpServletRequest request) {
//        if (!isAdmin(request)) {
//            return Result.error("无权限，只有管理员可以查看用户信息！");
//        }
//
//        try {
//            Map<String, Object> userInfo = userService.getSafeUserInfoById(id);
//            if (userInfo == null) {
//                return Result.error("用户不存在");
//            }
//            return Result.success(userInfo);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return Result.error("查询失败：" + e.getMessage());
//        }
//    }
    @GetMapping("/info/{userId}")
    public Result<Map<String, Object>> getSafeUserInfoById(@PathVariable Long userId,
                                                           HttpServletRequest request) {
        if (!isAdmin(request)) {
            return Result.error("无权限，只有管理员可以查看用户信息！");
        }

        try {
            Map<String, Object> userInfo = userService.getSafeUserInfoById(userId);
            if (userInfo == null) {
                return Result.error("用户不存在");
            }

            // ✅ 查询积分信息
            Map<String, Object> pointInfo = pointService.getUserPointsMap(userId);

            // ✅ 合并数据
            userInfo.putAll(pointInfo);

            return Result.success(userInfo);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 查询所有用户的下载次数（仅限管理员）
     */
//    @GetMapping("/downloads/all")
//    public Result<List<Map<String, Object>>> getAllUsersDownloadCounts(HttpServletRequest request) {
//        if (!isAdmin(request)) {
//            return Result.error("无权限操作，只有管理员可用！");
//        }
//
//        try {
//            List<Map<String, Object>> result = userService.getAllUsersDownloadCounts();
//            return Result.success(result);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return Result.error("查询失败：" + e.getMessage());
//        }
//    }
    @GetMapping("/downloads/all")
    public Result<PageResult<Map<String, Object>>> getAllUsersDownloadCounts(
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "10") int pageSize,
            HttpServletRequest request) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作，只有管理员可用！");
        }

        try {
            PageResult<Map<String, Object>> result = userService.getAllUsersDownloadCountsPaged(pageNum, pageSize);
            return Result.success(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }


    /**
     * 查询所有用户的上传次数（仅限管理员）
     */
//    @GetMapping("/uploads/all")
//    public Result<List<Map<String, Object>>> getAllUsersUploadCounts(HttpServletRequest request) {
//        if (!isAdmin(request)) {
//            return Result.error("无权限操作，只有管理员可用！");
//        }
//
//        try {
//            List<Map<String, Object>> result = userService.getAllUsersUploadCounts();
//            return Result.success(result);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return Result.error("查询失败：" + e.getMessage());
//        }
//    }
    @GetMapping("/uploads/all")
    public Result<PageResult<Map<String, Object>>> getAllUsersUploadCounts(
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "10") int pageSize,
            HttpServletRequest request) {
        if (!isAdmin(request)) {
            return Result.error("无权限操作，只有管理员可用！");
        }

        try {
            PageResult<Map<String, Object>> result = userService.getAllUsersUploadCountsPaged(pageNum, pageSize);
            return Result.success(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }


    /**
     * 查询所有用户的贡献值（仅限管理员）
     */
//    @GetMapping("/credits/all")
//    public Result<List<Map<String, Object>>> getAllUsersCredit(HttpServletRequest request) {
//        if (!isAdmin(request)) {
//            return Result.error("无权限操作，只有管理员可用！");
//        }
//
//        try {
//            List<Map<String, Object>> result = userService.getAllUsersCreditAndLevel();
//            return Result.success(result);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return Result.error("查询失败：" + e.getMessage());
//        }
//    }
    @GetMapping("/credits/all")
    public Result<PageResult<Map<String, Object>>> getAllUsersCredit(
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "10") int pageSize,
            HttpServletRequest request) {

        if (!isAdmin(request)) {
            return Result.error("无权限操作，只有管理员可用！");
        }

        try {
            PageResult<Map<String, Object>> result = userService.getAllUsersCreditAndLevelPaged(pageNum, pageSize);
            return Result.success(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }


}
